{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "相似度：[[0.9411986]]\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoTokenizer, AutoModel\n",
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "# 加载BERT模型和分词器\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-chinese\")\n",
    "model = AutoModel.from_pretrained(\"bert-base-chinese\")\n",
    "\n",
    "# 定义计算相似度的函数\n",
    "def calc_similarity(s1, s2):\n",
    "    # 对句子进行分词，并添加特殊标记\n",
    "    inputs1 = tokenizer(s1, return_tensors='pt', padding=True, truncation=True)\n",
    "    inputs2 = tokenizer(s2, return_tensors='pt', padding=True, truncation=True)\n",
    "    # 将输入传递给BERT模型，并获取输出\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs1)\n",
    "        embeddings1 = outputs.last_hidden_state[:, 0, :].cpu().numpy()\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs2)\n",
    "        embeddings2 = outputs.last_hidden_state[:, 0, :].cpu().numpy()\n",
    "    # print(embeddings1.shape) # (1, 768)\n",
    "    # 计算余弦相似度，并返回结果\n",
    "    sim = np.dot(embeddings1, embeddings2.T) / (np.linalg.norm(embeddings1) * np.linalg.norm(embeddings2))\n",
    "    return sim\n",
    "# input_ids = tokenizer.encode(\"文本相似度计算是自然语言处理中的一个重要问题\", \"自然语言处理中的一个重要问题是文本相似度计算\", return_tensors='pt')\n",
    "# print(input_ids)\n",
    "# 测试函数\n",
    "s1 = \"文本相似度计算是自然语言处理中的一个重要问题\"\n",
    "s2 = \"自然语言处理中的一个重要问题是文本相似度计算\"\n",
    "similarity = calc_similarity(s1, s2)\n",
    "print(f\"相似度：{similarity}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = 'E:/AI/CLIP-Chinese-master/data'\n",
    "import os\n",
    "train_file=os.path.join(root,'train1.csv')\n",
    "test_file=os.path.join(root,'test1.csv')\n",
    "train_pkl=os.path.join(root,'train.pkl')\n",
    "test_pkl=os.path.join(root,'test.pkl')\n",
    "import pandas as pd\n",
    "import pickle\n",
    "\n",
    "\n",
    "# # 加载存储的arr\n",
    "with open(test_pkl, 'rb') as f:\n",
    "    arr = pickle.load(f)\n",
    "df=pd.read_csv(test_file)\n",
    "data=[]\n",
    "for i in range(len(arr)):\n",
    "    data.append({'filename':df['filename'][i],'text':df['text'][i],'text_embed':arr[i]})\n",
    "\n",
    "#存储为pkl\n",
    "with open('test.pkl', 'wb') as f:\n",
    "    pickle.dump(data, f)\n",
    "\n",
    "with open(train_pkl, 'rb') as f:\n",
    "    arr = pickle.load(f)\n",
    "df=pd.read_csv(train_file)\n",
    "data=[]\n",
    "for i in range(len(arr)):\n",
    "    data.append({'filename':df['filename'][i],'text':df['text'][i],'text_embed':arr[i]})\n",
    "\n",
    "#存储为pkl\n",
    "with open('train.pkl', 'wb') as f:\n",
    "    pickle.dump(data, f)\n",
    "# 计算相似度\n",
    "# df.to_csv(train_file,index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "G:\\TEMP\\TEMP\\ipykernel_8008\\3172590468.py:238: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  clip_model.load_state_dict(torch.load('myCLIP.pth'))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from torch import nn\n",
    "import torch\n",
    "from collections import OrderedDict\n",
    "from torch.utils import checkpoint\n",
    "\n",
    "class LayerNorm(nn.LayerNorm):\n",
    "    \"\"\"Subclass torch's LayerNorm to handle fp16.\"\"\"\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        orig_type = x.dtype\n",
    "        ret = super().forward(x.type(torch.float32))\n",
    "        return ret.type(orig_type)\n",
    "\n",
    "\n",
    "class QuickGELU(nn.Module):\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        return x * torch.sigmoid(1.702 * x)\n",
    "\n",
    "\n",
    "class ResidualAttentionBlock(nn.Module):\n",
    "    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None, use_flash_attention: bool = False):\n",
    "        super().__init__()\n",
    "\n",
    "        self.attn = nn.MultiheadAttention(d_model, n_head)\n",
    "        self.ln_1 = LayerNorm(d_model)\n",
    "        self.mlp = nn.Sequential(OrderedDict([\n",
    "            (\"c_fc\", nn.Linear(d_model, d_model * 4)),\n",
    "            (\"gelu\", QuickGELU()),\n",
    "            (\"c_proj\", nn.Linear(d_model * 4, d_model))\n",
    "        ]))\n",
    "        self.ln_2 = LayerNorm(d_model)\n",
    "        self.attn_mask = attn_mask\n",
    "        self.use_flash_attention = use_flash_attention\n",
    "\n",
    "    def attention(self, x: torch.Tensor):\n",
    "        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None\n",
    "        if self.use_flash_attention:\n",
    "            # Batch first is needed for FlashAttention. See https://github.com/HazyResearch/flash-attention/issues/84 for more information.\n",
    "            return self.attn(x.transpose(1, 0))[0].transpose(1, 0)\n",
    "        else:\n",
    "            return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = x + self.attention(self.ln_1(x))\n",
    "        x = x + self.mlp(self.ln_2(x))\n",
    "        return x\n",
    "\n",
    "class Transformer(nn.Module):\n",
    "    def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None, use_flash_attention: bool = False):\n",
    "        super().__init__()\n",
    "        self.width = width\n",
    "        self.layers = layers\n",
    "        self.grad_checkpointing = False\n",
    "        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask, use_flash_attention) for _ in range(layers)])\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        if self.grad_checkpointing and not torch.jit.is_scripting():\n",
    "            for r in self.resblocks:\n",
    "                x = checkpoint(r, x)\n",
    "            return x        \n",
    "        return self.resblocks(x)\n",
    "\n",
    "\n",
    "class VisualTransformer(nn.Module):\n",
    "    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int, use_flash_attention: bool = False):\n",
    "        super().__init__()\n",
    "        self.dtype = torch.float32 #没有这一句会报错\n",
    "        self.input_resolution = input_resolution\n",
    "        self.grid_size = (self.input_resolution // patch_size, self.input_resolution // patch_size)\n",
    "        self.output_dim = output_dim\n",
    "        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)\n",
    "\n",
    "        scale = width ** -0.5\n",
    "        self.class_embedding = nn.Parameter(scale * torch.randn(width))\n",
    "        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))\n",
    "        self.ln_pre = LayerNorm(width)\n",
    "\n",
    "        self.transformer = Transformer(width, layers, heads, use_flash_attention=use_flash_attention)\n",
    "\n",
    "        self.ln_post = LayerNorm(width)\n",
    "        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))\n",
    "\n",
    "    @torch.jit.ignore\n",
    "    def set_grad_checkpointing(self, enable=True):\n",
    "        self.transformer.grad_checkpointing = enable\n",
    "\n",
    "    def random_masking(self, x, mask_ratio):\n",
    "        N, L, D = x.shape  # batch, length, dim\n",
    "        len_keep = int((L - 1) * (1 - mask_ratio))\n",
    "\n",
    "        noise = torch.rand(N, L - 1, device=x.device)\n",
    "        ids_shuffle = torch.argsort(noise, dim=1) + torch.ones(N, L - 1, device=x.device,\n",
    "                                                               dtype=int)\n",
    "        ids_keep = ids_shuffle[:, :len_keep]\n",
    "\n",
    "        x_masked = torch.gather(x, dim=1, index=ids_keep.unsqueeze(-1).repeat(1, 1, D))\n",
    "\n",
    "        x0 = x[:, 0, :]\n",
    "        x0 = x0.reshape(N, 1, D)\n",
    "        x_masked_add = torch.cat([x0, x_masked], axis=1)\n",
    "        return x_masked_add\n",
    "\n",
    "    def forward(self, x: torch.Tensor, mask_ratio: float = 0.0):\n",
    "        x = self.conv1(x)  # shape = [*, width, grid, grid]\n",
    "        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]\n",
    "        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]\n",
    "        x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, grid ** 2 + 1, width]\n",
    "        x = x + self.positional_embedding.to(x.dtype)\n",
    "        if mask_ratio != 0:\n",
    "            x = self.random_masking(x, mask_ratio)\n",
    "        x = self.ln_pre(x)\n",
    "\n",
    "        x = x.permute(1, 0, 2)  # NLD -> LND\n",
    "        x = self.transformer(x)\n",
    "        x = x.permute(1, 0, 2)  # LND -> NLD\n",
    "\n",
    "        x = self.ln_post(x[:, 0, :])\n",
    "\n",
    "        if self.proj is not None:\n",
    "            x = x @ self.proj\n",
    "\n",
    "        return x\n",
    "from torch import nn\n",
    "import numpy as np\n",
    "from typing import Union\n",
    "from typing import Tuple\n",
    "def contrastive_loss(logits: torch.Tensor) -> torch.Tensor:\n",
    "    return nn.functional.cross_entropy(logits, torch.arange(len(logits), device=logits.device))\n",
    "\n",
    "\n",
    "def clip_loss(similarity: torch.Tensor) -> torch.Tensor:\n",
    "    caption_loss = contrastive_loss(similarity)\n",
    "    image_loss = contrastive_loss(similarity.t())\n",
    "    return (caption_loss + image_loss) / 2.0\n",
    "\n",
    "class myCLIP(nn.Module):\n",
    "    def __init__(self,\n",
    "        embed_dim: int,\n",
    "        # text\n",
    "        text_hidden_size: int, #文本编码器最后一层隐藏层的维度\n",
    "        # vision\n",
    "        image_resolution: int,\n",
    "        vision_layers: Union[Tuple[int, int, int, int], int],\n",
    "        vision_width: int,\n",
    "        vision_patch_size: int,\n",
    "        # vision head width, added this param for ViT-H\n",
    "        vision_head_width: int = 64,\n",
    "        ):\n",
    "        super().__init__()\n",
    "        self.dtype = torch.float32 #没有这一句会报错\n",
    "        vision_heads = vision_width // vision_head_width\n",
    "        self.visual = VisualTransformer(\n",
    "                input_resolution=image_resolution,\n",
    "                patch_size=vision_patch_size,\n",
    "                width=vision_width,\n",
    "                layers=vision_layers,\n",
    "                heads=vision_heads,\n",
    "                output_dim=embed_dim,\n",
    "                # use_flash_attention=use_flash_attention\n",
    "            )\n",
    "        # self.visual = ModifiedResNet(\n",
    "        #         layers=vision_layers,\n",
    "        #         output_dim=embed_dim,\n",
    "        #         heads=vision_heads,\n",
    "        #         input_resolution=image_resolution,\n",
    "        #         width=vision_width\n",
    "        #     )\n",
    "        self.text_projection = nn.Parameter(torch.empty(text_hidden_size, embed_dim))\n",
    "        \n",
    "        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n",
    "        \n",
    "        # if isinstance(self.visual, ModifiedResNet):\n",
    "        #     if self.visual.attnpool is not None:\n",
    "        #         std = self.visual.attnpool.c_proj.in_features ** -0.5\n",
    "        #         nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)\n",
    "        #         nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)\n",
    "        #         nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)\n",
    "        #         nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)\n",
    "\n",
    "        #     for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:\n",
    "        #         for name, param in resnet_block.named_parameters():\n",
    "        #             if name.endswith(\"bn3.weight\"):\n",
    "        #                 nn.init.zeros_(param)\n",
    "\n",
    "        if self.text_projection is not None:\n",
    "            nn.init.normal_(self.text_projection, std=text_hidden_size ** -0.5)\n",
    "\n",
    "    def encode_image(self, image, mask_ratio=0):\n",
    "        # if isinstance(self.visual, ModifiedResNet):\n",
    "        #     # mask_ratio > 0 (FLIP strategy) is currently only implemented for VisualTransformer.\n",
    "        #     return self.visual(image.type(self.dtype))\n",
    "        return self.visual(image, mask_ratio)\n",
    "    \n",
    "    def forward(self, image, text_features, mask_ratio=0):\n",
    "        assert image is not None or text_features is not None, \"text_features and image cannot both be None!\"\n",
    "        \n",
    "        image_features = self.encode_image(image, mask_ratio)\n",
    "        if self.text_projection is not None:\n",
    "            text_features = text_features @ self.text_projection\n",
    "\n",
    "        image_features = image_features / image_features.norm(dim=-1, keepdim=True)\n",
    "        text_features = text_features / text_features.norm(dim=-1, keepdim=True)\n",
    "        logit_scale = self.logit_scale.exp()\n",
    "        logits_per_text = logit_scale * text_features @ image_features.t()\n",
    "        loss = clip_loss(logits_per_text)\n",
    "        return loss,image_features, text_features, self.logit_scale.exp()\n",
    "    def get_similarity(self, image, text_features):\n",
    "        image_features = self.encode_image(image)\n",
    "        text_features = text_features @ self.text_projection\n",
    "\n",
    "        # normalized features\n",
    "        image_features = image_features / image_features.norm(dim=1, keepdim=True)\n",
    "        text_features = text_features / text_features.norm(dim=1, keepdim=True)\n",
    "\n",
    "        # cosine similarity as logits\n",
    "        logit_scale = self.logit_scale.exp()\n",
    "        logits_per_image = logit_scale * image_features @ text_features.t()\n",
    "        logits_per_text = logits_per_image.t()\n",
    "\n",
    "        # shape = [global_batch_size, global_batch_size]\n",
    "        return logits_per_image, logits_per_text   \n",
    "import json\n",
    "args=\"\"\"{\n",
    "    \"embed_dim\": 512,\n",
    "    \"image_resolution\": 224,\n",
    "    \"vision_layers\": 6,\n",
    "    \"vision_width\": 768,\n",
    "    \"vision_patch_size\": 16\n",
    "}\"\"\"\n",
    "args=json.loads(args)\n",
    "embed_dim, text_hidden_size,image_resolution,vision_layers=args[\"embed_dim\"],768,args[\"image_resolution\"],args[\"vision_layers\"]\n",
    "vision_width=args[\"vision_width\"]\n",
    "vision_patch_size=args[\"vision_patch_size\"]\n",
    "vision_head_width=64\n",
    "clip_model=myCLIP(embed_dim=embed_dim,text_hidden_size=text_hidden_size,image_resolution=image_resolution,\n",
    "             vision_layers=vision_layers,vision_width=vision_width,vision_patch_size=vision_patch_size,\n",
    "             vision_head_width=vision_head_width)\n",
    "clip_model.load_state_dict(torch.load('myCLIP.pth'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[6.8396e-01, 4.4626e-04, 1.5613e-03,  ..., 2.2491e-05, 2.7073e-02,\n",
      "         9.9326e-05],\n",
      "        [5.7236e-04, 7.6892e-01, 1.0593e-03,  ..., 7.6842e-05, 1.1813e-03,\n",
      "         5.2090e-05],\n",
      "        [3.6168e-04, 8.4656e-04, 5.1883e-03,  ..., 5.1546e-03, 3.5467e-04,\n",
      "         5.2191e-03],\n",
      "        ...,\n",
      "        [8.2372e-05, 1.1174e-04, 5.8405e-04,  ..., 5.6906e-01, 6.2155e-05,\n",
      "         2.2497e-02],\n",
      "        [4.6879e-03, 3.4682e-03, 1.3251e-03,  ..., 3.6111e-06, 7.4894e-01,\n",
      "         1.0721e-05],\n",
      "        [1.0339e-04, 1.8386e-05, 6.0259e-04,  ..., 1.2291e-02, 5.4440e-04,\n",
      "         1.9497e-01]])\n",
      "tensor([ 0,  1,  4,  3,  4,  0,  6,  7,  8, 79, 10, 11, 12, 48, 79, 15, 16, 17,\n",
      "        18, 19, 20, 21, 22, 15, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
      "        33, 37, 38, 39, 40, 41, 42,  0, 44, 45, 46, 47, 48, 56, 50, 34, 52, 72,\n",
      "        54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,\n",
      "        72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 12, 85, 42, 87, 88, 89,\n",
      "        90, 38, 92, 93, 90, 95, 70, 97, 98, 90])\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoTokenizer, AutoModel\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "from PIL import Image\n",
    "from transformers import ChineseCLIPProcessor\n",
    "image_root=\"E:/AI/CLIP-Chinese-master/data/images\"\n",
    "with open(\"E:/AI/CLIP-Chinese-master/data/test1.csv\",\"r\",encoding=\"utf-8\") as f:\n",
    "    df=pd.read_csv(f)\n",
    "s1=df[\"text\"][0]\n",
    "# 加载BERT模型和分词器\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-chinese\")\n",
    "text_model = AutoModel.from_pretrained(\"bert-base-chinese\")\n",
    "\n",
    "images=[]\n",
    "text_embeds=[]\n",
    "for i in range(100):\n",
    "    inputs = tokenizer(df[\"text\"][i], return_tensors='pt', padding=True, truncation=True)\n",
    "    with torch.no_grad():\n",
    "        text_embed = text_model(**inputs).last_hidden_state[:, 0, :]\n",
    "    text_embeds.append(text_embed)\n",
    "    file=os.path.join(image_root,df[\"filename\"][i])\n",
    "    image = Image.open(file).convert('RGB')\n",
    "    images.append(image)\n",
    "text_embed=torch.concat(text_embeds)\n",
    "processor = ChineseCLIPProcessor.from_pretrained(\"OFA-Sys/chinese-clip-vit-base-patch16\")\n",
    "pixel_values=processor(images=images, return_tensors=\"pt\")[\"pixel_values\"]\n",
    "clip_model.eval()\n",
    "with torch.no_grad():\n",
    "    logits_per_image, logits_per_text=clip_model.get_similarity(pixel_values, text_embed)\n",
    "probs = logits_per_image.softmax(dim=1)\n",
    "print(probs)\n",
    "print(probs.argmax(dim=1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text: 这个表情包中的内容和笑点在于它展示了一个卡通熊猫人形象，熊猫人似乎在无奈地抱怨或讽刺某些事情。图片中的文字“破b网络真\n",
      "有意思”以一种幽默和夸张的方式表达了对网络上某些现象的不满或调侃。这种自嘲和讽刺的表达方式往往能引起共鸣，让人觉得好笑\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=224x224>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import pandas as pd\n",
    "import os\n",
    "image_root=\"E:/AI/CLIP-Chinese-master/data/images\"\n",
    "with open(\"E:/AI/CLIP-Chinese-master/data/test1.csv\",\"r\",encoding=\"utf-8\") as f:\n",
    "    df=pd.read_csv(f)\n",
    "# 展示第一个样本的图像和文本\n",
    "for i in range(1):\n",
    "    text = df[\"text\"][i]\n",
    "    image_path = os.path.join(image_root, df[\"filename\"][i])\n",
    "    image = Image.open(image_path).convert('RGB')\n",
    "    print(\"Text:\", text[:len(text)//2])\n",
    "    print(text[len(text)//2:-1])\n",
    "    #把图片展示到ipynb文件里\n",
    "    display(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "83\n"
     ]
    }
   ],
   "source": [
    "cnt=0\n",
    "a=probs.argmax(dim=1)\n",
    "for i in range(100):\n",
    "    if a[i]==i:\n",
    "        cnt+=1\n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Serving './demo.pth' at http://localhost:8080\n",
      "Serving './demo.pth' at http://localhost:8080\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('localhost', 8080)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import torch\n",
    "# import hiddenlayer as h\n",
    "# from torchvision.models import resnet18  # 以 resnet18 为例\n",
    "\n",
    "# myNet = resnet18()  # 实例化 resnet18\n",
    "# x = torch.randn(16, 3, 64, 64)  # 随机生成一个输入\n",
    "# myNetGraph = h.build_graph(myNet, x)  # 建立网络模型图\n",
    "# # myNetGraph.theme = h.graph.THEMES['blue']  # blue 和 basic 两种颜色，可以不要\n",
    "# myNetGraph.save(path='./demoModel.png', format='png')  # 保存网络模型图，可以设置 png 和 pdf 等\n",
    "# 针对有网络模型，但还没有训练保存 .pth 文件的情况\n",
    "import netron\n",
    "import torch.onnx\n",
    "from torch.autograd import Variable\n",
    "from torchvision.models import resnet18  # 以 resnet18 为例\n",
    "\n",
    "myNet = resnet18()  # 实例化 resnet18\n",
    "x = torch.randn(16, 3, 40, 40)  # 随机生成一个输入\n",
    "modelData = \"./demo.pth\"  # 定义模型数据保存的路径\n",
    "# modelData = \"./demo.onnx\"  # 有人说应该是 onnx 文件，但我尝试 pth 是可以的 \n",
    "torch.onnx.export(myNet, x, modelData)  # 将 pytorch 模型以 onnx 格式导出并保存\n",
    "netron.start(modelData)  # 输出网络结构\n",
    "\n",
    "#  针对已经存在网络模型 .pth 文件的情况\n",
    "import netron\n",
    "\n",
    "modelData = \"./demo.pth\"  # 定义模型数据保存的路径\n",
    "netron.start(modelData)  # 输出网络结构\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "file='./emo-visual-data/data.json'\n",
    "with open(file, 'r', encoding='utf-8') as f:\n",
    "    file = json.load(f)\n",
    "df = pd.DataFrame(file, columns=['filename','content'])\n",
    "#随机分成80%训练集和20%测试集\n",
    "train_df, test_df = df.sample(frac=0.8, random_state=42).reset_index(drop=True), df.drop(df.index[df.index < len(df)*0.8]).reset_index(drop=True)\n",
    "#将数据集保存为json文件\n",
    "train_df.to_json('./emo-visual-data/train.json', orient='records', force_ascii=False)\n",
    "test_df.to_json('./emo-visual-data/test.json', orient='records', force_ascii=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#把图片分辨率改成224*224\n",
    "from PIL import Image\n",
    "import os\n",
    "images_file = './emo-visual-data/emo'\n",
    "new_images_file = './emo-visual-data/images'\n",
    "for filename in os.listdir(images_file):\n",
    "    if filename.endswith('.jpg'):\n",
    "        img = Image.open(os.path.join(images_file, filename))\n",
    "        img = img.resize((224, 224))\n",
    "        img.save(os.path.join(new_images_file, filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import requests\n",
    "from transformers import ChineseCLIPProcessor, ChineseCLIPModel\n",
    "\n",
    "model = ChineseCLIPModel.from_pretrained(\"OFA-Sys/chinese-clip-vit-base-patch16\")\n",
    "processor = ChineseCLIPProcessor.from_pretrained(\"OFA-Sys/chinese-clip-vit-base-patch16\")\n",
    "\n",
    "url = \"https://clip-cn-beijing.oss-cn-beijing.aliyuncs.com/pokemon.jpeg\"\n",
    "# image = Image.open(requests.get(url, stream=True).raw)\n",
    "# image1 = Image.open('./emo-visual-data/images/0a0be697-2e42-4fbf-bbfe-ae0aae6bacb6.jpg')\n",
    "# image2 = Image.open('./emo-visual-data/images/0a1daae6-0e6d-4e7f-a32c-c92f569062fd.jpg')    \n",
    "# image=[image1,image2]\n",
    "# # Squirtle, Bulbasaur, Charmander, Pikachu in English\n",
    "# texts = [\"杰尼龟\", \"妙蛙种子\", \"小火龙\", \"皮卡丘\"]\n",
    "import json\n",
    "with open('./emo-visual-data/train.json') as f:\n",
    "    data = json.load(f)\n",
    "import pandas as pd\n",
    "df = pd.DataFrame(data, columns=['filename','content'])\n",
    "texts=df.head(10)['content'].tolist()\n",
    "image = []\n",
    "for filename in df.head(10)['filename'].tolist():\n",
    "    image.append(Image.open('./emo-visual-data/images/'+filename))\n",
    "\n",
    "# compute image feature\n",
    "inputs = processor(images=image, return_tensors=\"pt\")\n",
    "image_features = model.get_image_features(**inputs)\n",
    "image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)  # normalize\n",
    "\n",
    "# compute text features\n",
    "inputs = processor(text=texts, padding=True, return_tensors=\"pt\")\n",
    "text_features = model.get_text_features(**inputs)\n",
    "text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)  # normalize\n",
    "\n",
    "# compute image-text similarity scores\n",
    "inputs = processor(text=texts, images=image, return_tensors=\"pt\", padding=True)\n",
    "outputs = model(**inputs)\n",
    "logits_per_image = outputs.logits_per_image  # this is the image-text similarity score\n",
    "probs = logits_per_image.softmax(dim=1)  # probs: [[1.2686e-03, 5.4499e-02, 6.7968e-04, 9.4355e-01]]\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
